ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
; Handle the action on the map
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
; In:   SI = Current Map
;       DI = New Map
;       BX = Bytes per line
;       DH = 0 !!!
;
;
; Can change: AX DL BP
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ




ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
; Stone
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
Proc    Stone
        mov     al,06
        jmp     Fall_Roll
EndP    Stone


ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
; Dimond
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
Proc    Dimond
        mov     al,09
        jmp     Fall_Roll
EndP    Dimond


ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
; Make the stones or dimonds fall or roll
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
Fall_Roll:
        test    [Byte ds:si],10000000b
        jnz     @@20

; Object is NOT falling
        cmp     [Byte ds:si+bx],dh      ; Free space below?
        jne     Roll                    ; No, Test if we can roll
@@10:   mov     ah,[Byte ds:di]         ; Skipp if the object has changed
        and     ah,00011111b            ; on the new map
        cmp     ah,al
        jne     Return
        mov     [Byte ds:di],dh         ; Clear old
        or      al,10000000b            ; Set falling bit
        mov     [Byte ds:di+bx],al      ; Write new
        jmp     Return


; Object is falling
@@20:   mov     ah,[Byte ds:si+bx]      ; AH = Object below
        or      ah,ah                   ; Free space below?
        jz      @@10                    ; Continue falling
        and     ah,00011111b
        cmp     ah,12                   ; Don't clear falling bit if
        je      Return                  ; monster is below
        cmp     ah,15
        je      Return
        and     [Byte ds:di],01111111b  ; Clear falling bit
        jmp     Return


; Test if we can roll to the right
Roll:   cmp     [Byte ds:di+1],dh       ; Free space on right side?
        jne     @@30                    ; No, test for left
        cmp     [Byte ds:di+bx+1],dh    ; Free space below right side?
        jne     @@30                    ; No, test for left
        cmp     [Byte ds:di+bx],3       ; Only roll if object below is
        je      @@25                    ; an dimond, stone or brick wall
        cmp     [Byte ds:di+bx],6
        je      @@25
        cmp     [Byte ds:di+bx],9
        je      @@25
        jmp     @@30

; Roll right
@@25:   or      al,10000000b            ; Set falling bit
        mov     [Byte ds:di+1],al       ; Move one to the right
        mov     [Byte ds:di],dh         ; Clear old
        jmp     Return

; Test if we can roll to the left
@@30:   cmp     [Byte ds:di],al         ; Skipp if the object has changed on
        jne     Return                  ; the new map
        cmp     [Byte ds:di-1],dh       ; Free space on left side?
        jne     Return
        cmp     [Byte ds:di+bx-1],dh    ; Free space below left side?
        jne     Return
        cmp     [Byte ds:di+bx],3       ; Only roll if object below is
        je      @@35                    ; an dimond, stone or brick wall
        cmp     [Byte ds:di+bx],6
        je      @@35
        cmp     [Byte ds:di+bx],9
        je      @@35
        jmp     Return

; Roll left
@@35:   or      al,10000000b            ; Set falling bit
        mov     [Byte ds:di-1],al       ; Move one to the left
        mov     [Byte ds:di],dh         ; Clear old
        jmp     Return
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ





ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
; The special brick wall
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
Proc    Special_Wall
        mov     bp,bx
        neg     bp

        cmp     [Byte ds:Wall_Status],dh
        jne     @@20

; The wall is not active so check if wa shall start now
        cmp     [Byte ds:si+bp],134     ; Faling stone
        je      @@10
        cmp     [Byte ds:si+bp],137     ; Faling dimond
        je      @@10
        jmp     Return
        
@@10:   inc     [Byte ds:Wall_Status]   ; Yes, set active
        movzx   ax,[Byte ds:Magic_Time] ; Calculate finish time
        shl     ax,4
        sub     ax,[Word ds:Time]
        neg     ax   
        mov     [Word ds:Wall_Finished],ax


; The wall is active
@@20:   cmp     [Byte ds:si+bp],134     ; Faling stone
        je      @@30
        cmp     [Byte ds:si+bp],137     ; Faling dimond
        je      @@35
        jmp     Return

; Stone
@@30:   mov     al,137                  ; Transform to dimond
        jmp     @@90

; Dimond
@@35:   mov     al,134                  ; Transform to stone

; Do the transforming
@@90:   mov     [Byte ds:di+bp],dh      ; Clear old
        cmp     [Byte ds:di+bx],dh      ; Skipp if not room below
        jne     Return
        cmp     [Byte ds:Wall_Status],2 ; Skipp if wall are finished
        je      Return
        mov     [Byte ds:di+bx],al      ; Write new
        jmp     Return
EndP    Special_Wall
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ




;ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
; The green wierd stuff
;ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
Proc    Green
        cmp     [Byte ds:Green_Transform],dh
        jne     Transform

        cmp     [Byte ds:Green_Delay],dh
        jne     @@99

        cmp     [Byte ds:Green_Count],dh
        jne     @@20

; This is the first in the map, so get an "random" number and save it
; (ripped code...)
        push    bx cx dx
        mov     al,[Byte ds:Green_All]
        mov     cl,8
        cmp     al,256/2
        jae     @@01
        dec     cl
        cmp     al,256/4
        jae     @@01
        dec     cl
        cmp     al,256/8
        jae     @@01
        dec     cl
        cmp     al,256/16
        jae     @@01
        dec     cl
        cmp     al,256/32
        jae     @@01
        dec     cl
        cmp     al,256/64
        jae     @@01
        dec     cl

@@01:   xor     eax,eax
        mov     bl,[Byte ds:Random_Number]
        and     bl,1

@@00:   shl     eax,1       ; Make n bit numbers
        mov     edx,[Dword ds:Random_Number]

        shr     edx,9       ; shift arbitary 9 bits
        xor     bl,dl

        shr     edx,5       ; shift another arbitary 5 bits
        xor     bl,dl

        bt      ebx,1
        rcr     [Dword ds:Random_Number],1
        setc    bl
        or      al,bl

        dec     cl
        jnz     @@00

        mov     [Byte ds:Green_Expand],al
        pop     dx cx bx


; Check if it's time to expand our borders :)
@@20:   mov     bp,bx
        neg     bp                      ; BP = Ä Bytes per line
        cmp     [Byte ds:Green_Stop],1
        je      @@25
        mov     al,[Byte ds:Green_Expand]
        cmp     [Byte ds:Green_Count],al ; Time to expand?
        jne     @@99                     ; No, return

; Try to expand by one
@@25:   cmp     [Byte ds:di+bx],1
        ja      @@30
        mov     [Byte ds:di+bx],7
        jmp     @@40

@@30:   cmp     [Byte ds:di+bp],1
        ja      @@31
        mov     [Byte ds:di+bp],7
        jmp     @@40

@@31:   cmp     [Byte ds:di-1],1
        ja      @@32
        mov     [Byte ds:di-1],7
        jmp     @@40

@@32:   cmp     [Byte ds:di+1],1
        ja      @@39
        mov     [Byte ds:di+1],7
        jmp     @@40

@@39:   mov     [Byte ds:Green_Stop],1  ; No room to expand
        jmp     @@99

@@40:   inc     [Byte ds:Green_All]     ; We have expand one
        mov     [Byte ds:Green_Stop],dh
        mov     [Byte ds:Green_Traped],dh
        mov     [Byte ds:Green_Traped2],dh

; Ende
@@99:   inc     [Byte ds:Green_Count]
        jmp     Return


; Transform all the green stuff to new objects
Transform:
        mov     al,[Byte ds:Green_Transform]
        mov     [Byte ds:di],al
        jmp     Return
EndP    Green
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ





ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
; Control the monsters
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
Proc    Monster

; First check if the monster are going to die
        mov     bp,bx
        neg     bp
        mov     al,[Byte ds:di+bp]
        cmp     al,06 or 10000000b      ; Faling stone?
        je      @@00
        cmp     al,09 or 10000000b      ; Faling dimond?
        je      @@00
        and     al,00011111b
        cmp     al,7                    ; Green wierd stuff
        je      @@00
        cmp     [Byte ds:di+bx],7
        je      @@00
        cmp     [Byte ds:di+1],7
        je      @@00
        cmp     [Byte ds:di-1],7
        je      @@00
        jmp     @@05                    ; Ok!


; It died ;)
@@00:   test    [Byte ds:di],0011b
        jz      Explode
        mov     al,17 OR 01000000b      ; Explode and become dimonds
        jmp     Explode2


; Ok, monster still live
@@05:   push    cx
        mov     cx,bx                   ; Save BX (Bytes per line)
        mov     al,[Byte ds:di]
        mov     ah,al                   ; AH = Old object
        shr     al,5                    ; AL = Direction (0Ä3)


; Check if we can change direction
        Get_Index3
        cmp     [Byte ds:di+bp],dh
        je      Move_Right

@@10:   Get_Index
        cmp     [Byte ds:di+bp],dh      ; Can we continue?
        je      @@90                    ; Yes, move monster


; We have reached an end
@@15:   inc     al                      ; Change to next direction
        and     al,0011b
        shl     al,5
        and     ah,00011111b
        or      al,ah                   
        mov     [Byte ds:di],al         ; AL = Object with new direction
        jmp     @@99


; Move/Turn to the right
Move_Right:
        mov     dl,al                   ; Save old direction
        add     al,3                    ; Turn to the right
        and     al,0011b                ; *
        Get_Index2                      ; Check if we folow a wall
        cmp     [Byte ds:di+bx],dh
        jne     @@50
        cmp     [Byte ds:di+bp],dh
        jne     @@50

        mov     al,dl                   ; Direction is invalid, check if
        jmp     @@10                    ; we can continue old direction

; Yes, direction is valid
@@50:   mov     dl,al                   ; Move monster to new direction
        shl     dl,5
        and     ah,00011111b
        or      ah,dl
        jmp     @@10


; Move monster (BP = Where, AH = What)
@@90:   mov     [Byte ds:di],dh         ; Delete old
        mov     [Byte ds:di+bp],ah      ; Write new

@@99:   mov     bx,cx                   ; Restore bx
        pop     cx
        jmp     Return

EndP    Monster
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ





ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
; Explosion
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
Proc    Explosion
; We just increase the frame (17 Ä 19)
        mov     al,[Byte ds:di]
        inc     al
        cmp     al,20 OR 01000000b
        je      @@10
        cmp     al,20
        je      @@10
        jmp     @@99

; Delete or write dimonds
@@10:   and     al,11100000b
        jz      @@99
        mov     al,9
@@99:   mov     [Byte ds:di],al
        jmp     Return
EndP    Explosion
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ




; Do nothing, this is called every tick. Can be used as a low
; precition timer!
Proc    Home

        jmp     Return
EndP    Home




ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
; Control our hero
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
Proc    Guy
        mov     [Byte ds:Guy_Alive],dh  ; Yes, I'm alive :)

; Calculate position
        mov     bp,offset Map1
        cmp     [Byte ds:Curr_Map],dh
        je      @@00
        mov     bp,Offset Map2
@@00:   mov     ax,si
        sub     ax,bp                   ; AX = Guy's position in map
        div     bl
        mov     [Byte ds:Guy_V],al
        mov     [Byte ds:Guy_H],ah


        mov     bp,bx                   ; BP = Ä Bytes per line
        neg     bp

; Test if time is up
        test    [Byte ds:Finished],80h
        jnz     Explode

; Test if the guy died
@@02:   test    [Byte ds:si+bp],10000000b
        jnz     @@03                    ; The guy just smashed his head :)
        mov     al,[Byte ds:si+1]
        and     al,00011111b
        cmp     al,12
        je      @@03
        cmp     al,15
        je      @@03
        mov     al,[Byte ds:si+bx]
        and     al,00011111b
        cmp     al,12
        je      @@03
        cmp     al,15
        je      @@03
        mov     al,[Byte ds:si+bp]
        and     al,00011111b
        cmp     al,12
        je      @@03
        cmp     al,15
        je      @@03
        mov     al,[Byte ds:si-1]
        and     al,00011111b
        cmp     al,12
        je      @@03
        cmp     al,15
        je      @@03
        jmp     @@05

; Game over!
@@03:   mov     ax,Offset Dead_Str
        cmp     [Byte ds:Men],1
        jne     @@04
        mov     ax,Offset GameOver_Str
@@04:   mov     [Word ds:Info_String],ax
        mov     [Byte ds:Char_Space],2
        or      [Byte ds:Finished],80h
        jmp     Explode


; Do the moving and animation
@@05:   push    si
        mov     si,Offset Key_Map
        xor     dl,dl
        cmp     [Byte ds:si+Key_Up],dh          ; UP?
        je      @@06
@@Up:   mov     bp,bx
        neg     bp
        mov     dl,21
        mov     al,1
        cmp     [Byte ds:Last_Move],al          ; Priority new keys
        jne     Move

@@06:   cmp     [Byte ds:si+Key_Down],dh        ; DOWN?
        je      @@07
@@Down: mov     bp,bx
        mov     dl,21
        mov     al,2
        cmp     [Byte ds:Last_Move],al          ; Priority new keys
        jne     Move

@@07:   cmp     [Byte ds:si+Key_Left],dh        ; LEFT?
        je      @@08
@@Left: mov     bp,-1
        mov     dl,25
        mov     al,3
        cmp     [Byte ds:Last_Move],al          ; Priority new keys
        jne     Move

@@08:   cmp     [Byte ds:si+Key_Right],dh       ; RIGHT?
        je      @@09
@@Right:mov     bp,1
        mov     dl,22
        mov     al,4
        cmp     [Byte ds:Last_Move],al          ; Priority new keys
        jne     Move
@@09:   or      dl,dl                   ; Was any keys pressed at all?
        jnz     Move                    ; Yes, jump


; No move key is pressed!
        cmp     [Byte ds:Guy_Move],dh
        jne     @@10
        cmp     [Byte ds:Last_Key],dh
        je      @@10
        cmp     [Byte ds:Last_Key],Key_Up
        je      @@Up
        cmp     [Byte ds:Last_Key],Key_Down
        je      @@Down
        cmp     [Byte ds:Last_Key],Key_Left
        je      @@Left
        cmp     [Byte ds:Last_Key],Key_Right
        je      @@Right

@@10:   pop     si
        mov     [Byte ds:di],21
        mov     [Byte ds:Guy_Move],dh
        mov     [Byte ds:Last_Key],dh
        mov     [Byte ds:Last_Move],dh  ;???
        jmp     Return


; Move the guy, BP = Direction
Move:   pop     si
        mov     [Byte ds:Last_Move],al
        mov     [Byte ds:Guy_Move],1
        mov     [Byte ds:Last_Key],dh
        cmp     [Byte ds:di+bp],20      ; Home?
        jne     @@35
        cmp     [Byte ds:Finished],dh
        je      @@35

        inc     [Byte ds:Finished]      ; Move into home
        mov     dl,21                   ; Stand normal
        jmp      @@47


@@35:   cmp     [Byte ds:di+bp],1       ; Is move alowed?
        jbe     @@45                    ; Yes, jump
        cmp     [Byte ds:di+bp],9       ; Test for dimond
        jne     @@40                    ; Change frame, don't move
        jmp     Dimond_Taken            ; Return at @@45

; Check for and push bolder if posible
@@40:   cmp     dl,21                   ; Are we moving vertical?
        je      @@44                    ; Yes, pushing is impossible
        cmp     [Byte ds:di+bp],6       ; Bolder?
        jne     @@44                    ; No, skipp it
        movsx   ebp,bp
        cmp     [Byte ds:edi+ebp*2],dh  ; Free space behind bolder?
        jne     @@44
        cmp     [Byte ds:Frame2],dh     ; Delay
        jne     @@44
        mov     [Byte ds:edi+ebp*2],6   ; Move bolder
        je      @@45                    ; Move guy

@@44:   xor     bp,bp                   ; Change frame, don't move

@@45:   cmp     dl,21                   ; Shall we move vertical?
        jne     @@46                    ; No, skipp
        mov     dl,[Byte ds:Guy_Last]   ; Get old facing direction

@@46:   mov     [Byte ds:Guy_Last],dl   ; Save facing direction
        add     dl,[Byte ds:Walk_Frame] ; Change frame
        inc     [Byte ds:Walk_Frame]    ; Next frame
        cmp     [Byte ds:Walk_Frame],3
        jne     @@47
        mov     [Byte ds:Walk_Frame],dh


; DL = New guy icon to write, BP = Position
@@47:   cmp     [Byte ds:Key_Map+02Ah],dh       ; L-Shift down?
        jne     @@50
        cmp     [Byte ds:Key_Map+036h],dh       ; R-Shift down?
        jne     @@50


; Shift is NOT down        
        mov     [Byte ds:di],dh         ; Clear old
        mov     [Byte ds:di+bp],dl      ; Move
        jmp     Return

; Shift is down
@@50:   mov     [Byte ds:di+bp],dh      ; Clear new
        mov     [Byte ds:di],dl         ; DON'T move!

Skipp:  jmp     Return
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ



ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
; The guy has taken an dimond
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
Dimond_Taken:
        push    bx cx dx
        mov     eax,[Dword ds:Score]
        movzx   ebx,[Byte ds:D_Score]   ; Increase score
        add     [Dword ds:Score],ebx

        mov     ecx,[Dword ds:Score]    ; Check for extra life
        call    _Extra
        je      @@90

        mov     [Byte ds:Extra_Life],60
        inc     [Byte ds:Men]

@@90:   pop     dx cx bx
        inc     [Word ds:D_Count]       ; Increase dimond count
        movzx   ax,[Byte ds:D_Take]     ; Check if we are finished
        cmp     [Word ds:D_Count],ax
        jne     @@45                    ; No!

; We are finished!
        inc     [Byte ds:Finished]      ; Set flagg
        mov     al,[Byte ds:D_Score2]   ; Set new dimond score
        mov     [Byte ds:D_Score],al
        mov     [Word ds:Str_D_Take],'$$'
        mov     [Byte ds:Str_D_Take+2],'$'
        jmp     @@45
EndP    Guy
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ






ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
; Draw explosion, AL = What to draw
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
Explode:
        mov     al,17                   ; Default = Explosion
Explode2:
        mov     dl,3                    ; Draw the explosion (3 X 3)
@@10:   dec     bp
        mov     ah,3
@@20:   cmp     [Byte ds:di+bp],2       ; Don't explode the wall
        je      @@30
        cmp     [Byte ds:di+bp],20      ; Don't explode our home
        je      @@30
        cmp     [Byte ds:di+bp],7       ; Do we destroy the green stuff
        jne     @@25                    ; No, jump
        dec     [Byte ds:Green_All]     ; One less green stuff
@@25:   mov     [Byte ds:di+bp],al
        mov     [Byte ds:si+bp],16      ; Figure this one out your selv ;)
@@30:   inc     bp
        dec     ah
        jnz     @@20
        add     bp,bx
        dec     bp
        dec     bp
        dec     dl
        jnz     @@10
        jmp     Return
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ




ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
; Check for extra life
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
; In:   EAX = Old score
;       ECX = New score
;        
; Out:  ZF = 0 --> No (JE = NO)
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
Proc    _Extra
        mov     ebx,P_Extra
        xor     edx,edx
        div     ebx                     ; Old score / Extra Life
        push    ax
        mov     eax,ecx                 ; New score
        xor     edx,edx
        div     ebx                     ; New score / Extra Life
        pop     bx
        cmp     al,bl

        ret        
EndP    _Extra



ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
; An error in the map!  (Debug)
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
Proc    Map_Error
        add     sp,2+2*2                ; Remove Move_Map + registers
        mov     al,-1                   ; pushed in Play_Level
        ret
EndP    Map_Error
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
